package ma.ac.onousc.gestionfi.EngagementPaiement.services;

import java.util.List;

import javax.ejb.EJB;
import javax.ejb.Stateless;

import ma.ac.onousc.gestionfi.EngagementPaiement.model.Article;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Autres;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Beneficiaire;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.BonCommande;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Cheque;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Contrat;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Convention;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Devis;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Engagement;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Fournisseur;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Justificatif;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.LigneArticle;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.LotMarche;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Marche;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.OrdrePaiement;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.OrdrePaiementAnnulation;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.OrdreVirement;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.Prestation;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.TypeEngagement;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.TypeJustificatif;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.TypePrestation;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.ArticleDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.AutresDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.BeneficiaireDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.BonCommandeDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.ChequeDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.ContratDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.ConventionDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.DevisDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.EngagementDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.FournisseurDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.JustificatifDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.LigneArticleDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.LotMarcheDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.MarcheDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.OrdrePaiementAnnulationDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.OrdrePaiementDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.OrdreVirementDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.PrestationDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.TypeEngagementDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.TypeJustificatifDAO;
import ma.ac.onousc.gestionfi.EngagementPaiement.model.DAO.TypePrestationDAO;
import ma.ac.onousc.gestionfi.budget.model.RubriqueBudgetaire;

@Stateless(name = "engagementPaiementServices")
public class EngagementPaiementServices implements EngagementPaiementManager {


	//Engagement & Paiement
	@EJB
	EngagementDAO engagementDAO;
	@EJB
	BonCommandeDAO bonCommandeDAO;
	@EJB
	DevisDAO devisDAO;
	@EJB
	ArticleDAO articleDAO;
	@EJB
	LigneArticleDAO ligneArticleDAO;
	@EJB
	FournisseurDAO fournisseurDAO;
	@EJB
	AutresDAO autresDAO;
	@EJB
	BeneficiaireDAO beneficiaireDAO;
	@EJB
	ContratDAO contratDAO;
	@EJB
	ConventionDAO conventionDAO;
	@EJB
	MarcheDAO marcheDAO;
	@EJB
	LotMarcheDAO lotMarcheDAO;
	@EJB
	OrdrePaiementDAO ordrePaiementDAO;
	@EJB
	OrdrePaiementAnnulationDAO ordrePaiementAnnulationDAO;
	@EJB
	JustificatifDAO justificatifDAO;
	@EJB
	PrestationDAO prestationDAO;
	@EJB
	TypePrestationDAO typePrestationDAO;
	@EJB
	TypeEngagementDAO typeEngagementDAO;
	@EJB
	TypeJustificatifDAO typeJustificatifDAO;
	@EJB
	OrdreVirementDAO ordreVirementDAO;
	@EJB
	ChequeDAO chequeDAO;
	
	//////////////////////////////

	@Override
	public Article makePersistent(Article article) {
		return articleDAO.makePersistent(article);
	}


	@Override
	public Fournisseur makePersistent(Fournisseur FourEntity) {

		return fournisseurDAO.makePersistent(FourEntity);
	}


	@Override
	public List<Engagement> findByRB(RubriqueBudgetaire rb) {
		return engagementDAO.findByRB(rb);
	}

	@Override
	public List<Prestation> findByTypePrestation(TypePrestation prest) {
		return prestationDAO.findByTypePrestation(prest);
	}

	@Override
	public TypePrestation makePersistent(TypePrestation prest) {
		return typePrestationDAO.makePersistent(prest);
		
	}

	@Override
	public Engagement makePersistent(Engagement eng) {
		return this.engagementDAO.makePersistent(eng);
	}

	@Override
	public void makeTransient(Engagement eng) {
		this.engagementDAO.makeTransient(eng);
		
	}

	@Override
	public List<Engagement> findAllEngagement() {
		return this.engagementDAO.findAll();
		
	}

	@Override
	public Engagement findEngagementById(int id) {
		return this.engagementDAO.findById(id);
	}

	@Override
	public BonCommande makePersistent(BonCommande bc) {
		return this.bonCommandeDAO.makePersistent(bc);
	}

	@Override
	public void makeTransient(BonCommande bc) {
		this.bonCommandeDAO.makeTransient(bc);
		
	}

	@Override
	public List<BonCommande> findAllBonCommande() {
		return this.bonCommandeDAO.findAll();
	}

	@Override
	public BonCommande findBonCommandeById(int id) {
		return this.bonCommandeDAO.findById(id);
	}
	
	@Override
	public TypeEngagement makePersistent(TypeEngagement typeEngagement) {
		return this.typeEngagementDAO.makePersistent(typeEngagement);
	}

	@Override
	public void makeTransient(TypeEngagement typeEngagement) {
		this.typeEngagementDAO.makeTransient(typeEngagement);
		
	}

	@Override
	public List<TypeEngagement> findAllTypeEngagement() {
		return this.typeEngagementDAO.findAll();
	}

	@Override
	public TypeEngagement findTypeEngagementById(int id) {
		return this.typeEngagementDAO.findById(id);
	}
	
	

	@Override
	public Devis makePersistent(Devis devis) {
		return this.devisDAO.makePersistent(devis);
	}

	@Override
	public void makeTransient(Devis devis) {
		this.devisDAO.makeTransient(devis);
		
	}

	@Override
	public List<Devis> findAllDevis() {
		return this.devisDAO.findAll();
	}

	@Override
	public Devis findDevisById(int id) {
		return this.devisDAO.findById(id);
	}

	@Override
	public void makeTransient(Article article) {
		this.articleDAO.makeTransient(article);
		
	}

	@Override
	public List<Article> findAllArticle() {
		return this.articleDAO.findAll();
	}

	@Override
	public Article findArticleById(int id) {
		return this.articleDAO.findById(id);
	}

	@Override
	public LigneArticle makePersistent(LigneArticle ligneArticle) {
		return this.ligneArticleDAO.makePersistent(ligneArticle);
	}

	@Override
	public void makeTransient(LigneArticle ligneArticle) {
		this.ligneArticleDAO.makeTransient(ligneArticle);
		
	}

	@Override
	public List<LigneArticle> findAllLigneArticle() {
		return this.ligneArticleDAO.findAll();
	}

	@Override
	public LigneArticle findLigneArticleById(int id) {
		return this.ligneArticleDAO.findById(id);
	}

	@Override
	public void makeTransient(Fournisseur fournisseur) {
		 this.fournisseurDAO.makeTransient(fournisseur);
		
	}

	@Override
	public List<Fournisseur> findAllFournisseur() {
		return this.fournisseurDAO.findAll();
	}

	@Override
	public Fournisseur findFournisseurById(int id) {
		return this.fournisseurDAO.findById(id);
	}

	@Override
	public void makeTransient(TypePrestation tPrest) {
		this.typePrestationDAO.makeTransient(tPrest);
		
	}

	@Override
	public List<TypePrestation> findAllTypePrestation() {
		return this.typePrestationDAO.findAll();
	}

	@Override
	public TypePrestation findTypePrestationById(int id) {
		return this.typePrestationDAO.findById(id);
	}

	@Override
	public Autres makePersistent(Autres autres) {
		return this.autresDAO.makePersistent(autres);
	}

	@Override
	public void makeTransient(Autres autres) {
		this.autresDAO.makeTransient(autres);
		
	}

	@Override
	public List<Autres> findAllAutres() {
		return this.autresDAO.findAll();
	}

	@Override
	public Autres findAutresById(int id) {
		return this.autresDAO.findById(id);
	}

	@Override
	public Beneficiaire makePersistent(Beneficiaire beneficiaire) {
		return this.beneficiaireDAO.makePersistent(beneficiaire);
	}

	@Override
	public void makeTransient(Beneficiaire beneficiaire) {
		this.beneficiaireDAO.makeTransient(beneficiaire);
		
	}

	@Override
	public List<Beneficiaire> findAllBeneficiaire() {
		return this.beneficiaireDAO.findAll();
	}

	@Override
	public Beneficiaire findBeneficiaireById(int id) {
		return this.beneficiaireDAO.findById(id);
	}

	@Override
	public Contrat makePersistent(Contrat contrat) {
		return this.contratDAO.makePersistent(contrat);
	}

	@Override
	public void makeTransient(Contrat contrat) {
		this.contratDAO.makeTransient(contrat);
		
	}

	@Override
	public List<Contrat> findAllContrat() {
		return this.contratDAO.findAll();
	}

	@Override
	public Contrat findContratById(int id) {
		return this.contratDAO.findById(id);
	}

	@Override
	public Convention makePersistent(Convention convention) {
		return this.conventionDAO.makePersistent(convention);
	}

	@Override
	public void makeTransient(Convention convention) {
		this.conventionDAO.makeTransient(convention);
		
	}

	@Override
	public List<Convention> findAllConvention() {
		return this.conventionDAO.findAll();
	}

	@Override
	public Convention findConventionById(int id) {
		return this.conventionDAO.findById(id);
	}

	@Override
	public Marche makePersistent(Marche marche) {
		return this.marcheDAO.makePersistent(marche);
	}

	@Override
	public void makeTransient(Marche marche) {
		this.marcheDAO.makeTransient(marche);
	}

	@Override
	public List<Marche> findAllMarche() {
		return this.marcheDAO.findAll();
	}

	@Override
	public Marche findMarcheById(int id) {
		return this.marcheDAO.findById(id);
	}

	@Override
	public LotMarche makePersistent(LotMarche lotLotMarche) {
		return this.lotMarcheDAO.makePersistent(lotLotMarche);
	}

	@Override
	public void makeTransient(LotMarche lotLotMarche) {
		this.lotMarcheDAO.makeTransient(lotLotMarche);
	}

	@Override
	public List<LotMarche> findAllLotMarche() {
		return this.lotMarcheDAO.findAll();
	}

	@Override
	public LotMarche findLotMarcheById(int id) {
		return this.lotMarcheDAO.findById(id);
	}


	@Override
	public OrdrePaiement makePersistent(OrdrePaiement ordrePaiement) {
		return this.ordrePaiementDAO.makePersistent(ordrePaiement);
	}

	@Override
	public void makeTransient(OrdrePaiement ordrePaiement) {
		this.ordrePaiementDAO.makeTransient(ordrePaiement);
	}

	@Override
	public List<OrdrePaiement> findAllOrdrePaiement() {
		return this.ordrePaiementDAO.findAll();
	}

	@Override
	public OrdrePaiement findOrdrePaiementById(int id) {
		return this.ordrePaiementDAO.findById(id);
	}

	@Override
	public OrdrePaiementAnnulation makePersistent(OrdrePaiementAnnulation ordrePaiementAnnulation) {
		return this.ordrePaiementAnnulationDAO.makePersistent(ordrePaiementAnnulation);
	}

	@Override
	public void makeTransient(OrdrePaiementAnnulation ordrePaiementAnnulation) {
		this.ordrePaiementAnnulationDAO.makeTransient(ordrePaiementAnnulation);
	}

	@Override
	public List<OrdrePaiementAnnulation> findAllOrdrePaiementAnnulation() {
		return this.ordrePaiementAnnulationDAO.findAll();
	}

	@Override
	public OrdrePaiementAnnulation findOrdrePaiementAnnulationById(int id) {
		return this.ordrePaiementAnnulationDAO.findById(id);
	}

	@Override
	public Justificatif makePersistent(Justificatif justificatif) {
		return this.justificatifDAO.makePersistent(justificatif);
	}

	@Override
	public void makeTransient(Justificatif justificatif) {
		this.justificatifDAO.makeTransient(justificatif);
	}

	@Override
	public List<Justificatif> findAllJustificatif() {
		return this.justificatifDAO.findAll();
	}

	@Override
	public Justificatif findJustificatifById(int id) {
		return this.justificatifDAO.findById(id);
	}

	

	@Override
	public Prestation makePersistent(Prestation prestation) {
		return this.prestationDAO.makePersistent(prestation);
	}

	@Override
	public void makeTransient(Prestation prestation) {
		this.prestationDAO.makeTransient(prestation);
	}

	@Override
	public List<Prestation> findAllPrestation() {
		return this.prestationDAO.findAll();
	}

	@Override
	public Prestation findPrestationById(int id) {
		return this.prestationDAO.findById(id);
	}

	@Override
	public OrdreVirement makePersistent(OrdreVirement ordreVirement) {
		return this.ordreVirementDAO.makePersistent(ordreVirement);
	}

	@Override
	public void makeTransient(OrdreVirement ordreVirement) {
		this.ordreVirementDAO.makeTransient(ordreVirement);
	}

	@Override
	public List<OrdreVirement> findAllOrdreVirement() {
		return this.ordreVirementDAO.findAll();
	}

	@Override
	public OrdreVirement findOrdreVirementById(int id) {
		return this.ordreVirementDAO.findById(id);
	}

	@Override
	public Cheque makePersistent(Cheque cheque) {
		return this.chequeDAO.makePersistent(cheque);
	}

	@Override
	public void makeTransient(Cheque cheque) {
		this.chequeDAO.makeTransient(cheque);
	}

	@Override
	public List<Cheque> findAllCheque() {
		return this.chequeDAO.findAll();
	}

	@Override
	public Cheque findChequeById(int id) {
		return this.chequeDAO.findById(id);
	}

	


	@Override
	public List<TypePrestation> findByTypeEngagement(TypeEngagement te) {
		return typePrestationDAO.findByTypeEngagement(te);
	}


	@Override
	public List<BonCommande> findBonCommandeByRB(RubriqueBudgetaire rb) {
		return bonCommandeDAO.findByRB(rb);
	}


	@Override
	public List<Autres> findAutresByRB(RubriqueBudgetaire rb) {
		return autresDAO.findByRB(rb);
	}


	@Override
	public List<Contrat> findContratByRB(RubriqueBudgetaire rb) {
		return contratDAO.findByRB(rb);
	}


	@Override
	public List<Convention> findConventionByRB(RubriqueBudgetaire rb) {
		return conventionDAO.findByRB(rb);
	}


	@Override
	public List<Marche> findMarcheByRB(RubriqueBudgetaire rb) {
		return marcheDAO.findByRB(rb);
	}


	@Override
	public List<Devis> findByBC(BonCommande bc) {
		return devisDAO.findByBC(bc);
	}


	@Override
	public List<LotMarche> findByMarche(Marche mar) {
		return lotMarcheDAO.findByMarche(mar);
	}


	@Override
	public TypeJustificatif makePersistent(TypeJustificatif eng) {
		return this.typeJustificatifDAO.makePersistent(eng);
	}


	@Override
	public void makeTransient(TypeJustificatif eng) {
		this.typeJustificatifDAO.makeTransient(eng);
		
	}


	@Override
	public List<TypeJustificatif> findAllTypeJustificatif() {
		return this.typeJustificatifDAO.findAll();
	}


	@Override
	public TypeJustificatif findTypeJustificatifById(int id) {
		return this.typeJustificatifDAO.findById(id);
	}
}
